package cn.openea.perpartner.rule.util;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;
import java.util.*;

/**
 * @author Weird077
 * @description TODO
 * @date 2022-10-09 10:32
 */
public class Tools extends StrUtil {
    static Logger logger = LoggerFactory.getLogger(Tools.class);
    /**
     * ArrayList转字符串
     * @param array List对像
     * @param key   分隔字符串
     * @return 返回字符串
     */
    public static String join(ArrayList<String> array, String key) {
        StringBuilder str = new StringBuilder();
        int i = 0;
        for (String item : array) {
            if (i == 0) {
                str.append(item);
                i = 1;
            } else {
                str.append(key + item);
            }
        }
        return str.toString();
    }

    /**
     * Set转字符串同时去掉空值
     *
     * @param set 对像
     * @param key 分隔字符串
     * @return 返回逗号分隔的字符串
     */
    public static String join(Set<String> set, String key) {
        StringBuilder fdNameList = new StringBuilder();
        int i = 0;
        set.remove("");
        for (String item : set) {
            if (i == 0) {
                fdNameList.append(item);
                i = 1;
            } else {
                fdNameList.append(key + item);
            }
        }
        return fdNameList.toString();
    }

    /**
     * 把字符串按逗号分解成为字符串数组
     *
     * @param str 要分析的字符串
     * @return 字符串数组
     */
    public static String[] split(String str) {
        return split(str, ",");
    }

    /**
     * 把字符串分解成为字符串数组
     *
     * @param str 要分析的字符串
     * @param key 关键字符串
     * @return 字符串数组
     */
    public static String[] split(String str, String key) {
        if (key.length() > 1) {
            return StringUtils.splitByWholeSeparator(str, key);
        } else {
            return StringUtils.split(str, key);
        }
    }

    /**
     * 把字符串的两端空格去掉
     * @param str 要去掉两端空格的字符串
     * @return 去掉两端空格后的字符串
     */
    public static String trim(String str) {
        return StringUtils.trim(str);
    }

    /**
     * 替换字符串
     * @param text         要替找的字符串
     * @param searchString 旧字符串
     * @param replacement  新字符串
     * @return 替换后的字符串
     */
    public static String replace(String text, String searchString, String replacement) {
        return StringUtils.replace(text, searchString, replacement);
    }

    /**
     * 替换字符串一次
     * @param text         要替找的字符串
     * @param searchString 旧字符串
     * @param replacement  新字符串
     * @return 替换后的字符串
     */
    public static String replaceOne(String text, String searchString, String replacement) {
        return StringUtils.replaceOnce(text, searchString, replacement);
    }

    /**
     * 把字符串切分为字List集合对像
     * @param str 要切分的字符串
     * @param key 关键字
     * @return List集合
     */
    public static List<String> splitAsList(String str, String key) {
        if (str == null) {
            str = "";
        }
        return Arrays.asList(StringUtils.split(str, key));
    }

    /**
     * 把字符串按逗号切分为字List集合对像
     * @param str 要切分的字符串
     * @return List集合
     */
    public static List<String> splitAsList(String str) {
        return splitAsList(str, ",");
    }

    /**
     * 把字符串按逗号切分为字Set集合对像同时会去掉重复值,这个函数有问题
     * @param str 要切分的字符串
     * @return HashSet集合
     */
    public static HashSet<String> splitAsSet(String str) {
        return splitAsSet(str, ",");
    }

    /**
     * 把字符串切分为字Set集合对像同时会去掉重复值, 这个函数有问题，复杂字符串时会出错
     * @param str 要切分的字符串
     * @param key 关键字
     * @return HashSet集合
     */
    public static HashSet<String> splitAsSet(String str, String key) {
        String[] strArray = StringUtils.split(str, key);
        HashSet<String> set = new HashSet<String>(strArray.length);
        for (String item : strArray) {
            set.add(item);
        }
        return set;
    }

    /**
     * 把字符串切分为字LinkedHashSet集合对像同时会去掉重复值, 这个函数有问题，复杂字符串时会出错
     * @param str 要切分的字符串
     * @return 切分后的LinkedHashSet集合
     */
    public static LinkedHashSet<String> splitAsLinkedSet(String str) {
        return splitAsLinkedSet(str, ",");
    }

    /**
     * 把字符串切分为字LinkedHashSet集合对像同时会去掉重复值, 这个函数有问题，复杂字符串时会出错
     * @param str 要切分的字符串
     * @param key 关键字
     * @return LinkedHashSet集合
     */
    public static LinkedHashSet<String> splitAsLinkedSet(String str, String key) {
        String[] strArray = StringUtils.split(str, key);
        LinkedHashSet<String> set = new LinkedHashSet<>(strArray.length);
        for (String item : strArray) {
            set.add(item);
        }
        return set;
    }
    /**
     * 获得一个给定长度的随机字符串
     *
     * @param length 随机字符串的长度
     * @return 随机字符串
     */
    public static String getRandom(int length) {
        String allChar = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        StringBuffer sb = new StringBuffer();
        Random random = new Random();
        for (int i = 0; i < length; i++) {
            sb.append(allChar.charAt(random.nextInt(allChar.length())));
        }
        return sb.toString();
    }
    /**
     * 对字符串进行json格式的编码
     * @param str 要编码的json值
     * @return 编码后的json字符串
     */
    public static String encodeJson(String str) {
        str = str.replace("\\", "\\\\");
        str = str.replace("/", "\\/");
        str = str.replace("\"", "\\\"");
        str = str.replace("\n", "\\n");
        str = str.replace("\r", "\\r");
        str = str.replace("\b", "\\b");
        str = str.replace("\f", "\\f");
        str = str.replace("\t", "\\t");
        return str;
    }
    /**
     * 去除数组中的""空值
     * @param array 字符串数组
     * @return 去掉数组中空字符串元素后的数组
     */
    public static String[] fullTrim(String[] array) {
        ArrayList<String> list = (ArrayList<String>) Arrays.asList(array);
        list.remove("");
        return (String[]) list.toArray();
    }
    /**
     * json字符串转为hashmap对像,json字符串格式为{"fieldName1":"字段值","fdName2":"value2"}
     * @param jsonStr json字符串
     * @return HashMap对象
     */
    public static HashMap<String, String> jsonStr2Map(String jsonStr) {
        JSONObject jsonobj = JSON.parseObject(jsonStr);
        HashMap<String, String> map = new HashMap<String, String>(jsonobj.size());
        for (String fdName : jsonobj.keySet()) {
            map.put(fdName, jsonobj.getString(fdName));
        }
        return map;
    }
    /**
     * 对字符串进行utf-8解码,只能解码utf-8格式的编码
     * @param str 要解码的字符串
     * @return 解码后的字符串，若抛出异常，返回空字符串
     */
    public static String decode(String str) {
        try {
            return java.net.URLDecoder.decode(str, "utf-8");
        } catch (Exception e) {
            logger.error("字符串解码失败({})",str);
            return "";
        }
    }
    /**
     * 兼容解码方式，先判断是不是ISO-8859-1编码，否则以utf-8进行解码
     * @param str 要解码的字符串
     * @return 解码后的字符串，若抛出异常，返回空字符串
     */
    public static String decodeAll(String str) {
        //20180428 修改解码方法，兼容Oracle/MySQL数据库，使用Tools.encode(fileName)进行解码
        try {
            if (str.equals(new String(str.getBytes("ISO-8859-1"), "ISO-8859-1"))) {
                str = Tools.decodeUrl(str);
            } else {
                str = Tools.decode(str);
            }
        } catch (UnsupportedEncodingException e1) {
            logger.error("字符串解码失败({})",str);
            return "";
        }
        return str;
    }
    /**
     * 对字符串进行utf-8编码
     *
     * @param str 要编码的字符串
     * @return 返回编码后的字符串
     */
    public static String encode(String str) {
        try {
            String code = java.net.URLEncoder.encode(str, "utf-8");
            code = code.replace("+", "%20");
            return code;
        } catch (Exception e) {
            logger.error("字符串解码失败({})",str);
            return str;
        }
    }
    /**
     * 解码url中传的中文字符串,url中的中文字符串必须要用utf-8格式进行编码 js可以用encodeURIComponent()函数，java可以用Tools.encode()方法
     * @param qry 要解码的url
     * @return 返回解码后的字符串
     */
    public static String decodeUrl(String qry) {
        try {
            qry = new String(qry.getBytes("ISO-8859-1"), "UTF-8");
        } catch (Exception e) {
            logger.error("Query string decode error");
        }
        return qry;
    }
    /**
     * 格式化成标准的json响应字符串
     *
     * @param status 状态：ok error ....
     * @param msg 要返回的提示消息
     * @return 格式化后的json字符串
     */
    public static String jmsg(String status, String msg) {
        return "{\"Status\":\"" + status + "\",\"msg\":\"" + msg + "\"}";
    }
}
